<template>
	<div class="second-level">
		<div class="game-canvas-container">
			<canvas ref="gameCanvas"></canvas>
		</div>
		
		<!-- 引入公共游戏组件 -->
		<GameComponents
			:isPaused="isPaused"
			:gameOver="gameOver"
			:gameWon="gameWon"
			:resultMessage="resultMessage"
			:showExitConfirm="showExitConfirm"
			:remainingTime="remainingTime"
			:totalAiCount="totalAiCount"
			:aliveAiCount="aliveAiCount"
			@pause="togglePause"
			@resume="resumeGame"
			@restart="restartGame"
			@exit="exitGame"
			@simulateCompletion="simulateCompletion"
			@closeExitConfirm="showExitConfirm = $event"
		/>
	</div>
</template>

<script setup>
import { onMounted, onUnmounted, ref, computed, defineEmits, watch } from 'vue'
import { SingleMap } from '@/assets/scripts/single/SingleMap'
import { GameObject } from '@/assets/scripts/GameObject'
import GameComponents from '@/components/GameComponents.vue'

// 定义发射事件
const emit = defineEmits(['complete'])

// 游戏状态
const gameCanvas = ref(null)
const gameMap = ref(null)
const gameOver = ref(false)
const gameWon = ref(false)
const resultMessage = ref('') // 结果消息
const remainingTime = ref(60) // 60秒倒计时
const timerInterval = ref(null) // 倒计时定时器
const isPaused = ref(false) // 游戏是否暂停
const showExitConfirm = ref(false) // 是否显示退出确认

// 游戏数据
const totalAiCount = ref(0)
const deadAiCount = ref(0) // 死亡AI计数器

// 计算属性：存活的AI数量(纯函数，没有副作用)
const aliveAiCount = computed(() => {
	if (!gameMap.value || !gameMap.value.players) return 0
	
	// 直接返回计算结果，不修改任何状态
	return totalAiCount.value - deadAiCount.value
})

// 更新AI存活状态的函数（独立于计算属性）
const updateAiStatus = () => {
	if (!gameMap.value || !gameMap.value.players) return
	
	// 计算当前实际死亡的AI数量
	const aiPlayers = gameMap.value.players.filter(p => p.info.role === 'AI')
	const deadAIs = aiPlayers.filter(p => p.is_dead || p.info.hp <= 0)
	
	// 如果计数与实际不符，更新死亡计数
	if (deadAIs.length !== deadAiCount.value) {
		deadAiCount.value = deadAIs.length
		console.log(`更新AI死亡计数: ${deadAiCount.value}/${totalAiCount.value}`)
	}
}

// 修改AI行为，禁用攻击和治疗能力
const modifyAiBehavior = () => {
	if (!gameMap.value || !gameMap.value.players) return
	
	console.log('正在修改AI行为，当前AI数量:', gameMap.value.players.filter(p => p.info.role === 'AI').length)
	
	// 修改所有AI的行为
	gameMap.value.players.forEach(player => {
		if (player.info.role === 'AI') {
			// 完全替换AI的update_AI_behavior方法，移除攻击和治疗行为
			player.update_AI_behavior = function() {
				// 如果玩家已死亡，不做任何事
				if (this.is_dead) {
					return
				}
				
				// 确保技能系统已初始化
				if (!this.skills) {
					this.initialize_skills()
				}
				
				// 获取玩家
				let player = null
				for (let i = 0; i < this.gameMap.players.length; i++) {
					if (this.gameMap.players[i].info.role === 'me' && !this.gameMap.players[i].is_dead) {
						player = this.gameMap.players[i]
						break
					}
				}
				
				// AI行为逻辑：只有躲避和移动，没有攻击和治疗
				if (player) {
					// 计算与玩家的距离
					const dist = this.get_dist(this.info.x, this.info.y, player.info.x, player.info.y)
					
					// AI移动行为 - 主动躲避玩家
					if (dist < this.gameMap.height * 0.4 || Math.random() < 0.02) {
						// 距离太近，远离玩家
						const angle = Math.atan2(this.info.y - player.info.y, this.info.x - player.info.x)
						const moveDistance = this.gameMap.width * 0.3
						const moveX = this.info.x + Math.cos(angle) * moveDistance
						const moveY = this.info.y + Math.sin(angle) * moveDistance
						this.move_to(moveX, moveY)
					} else if (Math.random() < 0.01) {
						// 随机移动
						const randomAngle = Math.random() * Math.PI * 2
						const moveDistance = this.gameMap.width * 0.2
						const moveX = this.info.x + Math.cos(randomAngle) * moveDistance
						const moveY = this.info.y + Math.sin(randomAngle) * moveDistance
						this.move_to(moveX, moveY)
					}
				} else {
					// 没有玩家时，随机移动
					if (Math.random() < 0.01) {
						const randomAngle = Math.random() * Math.PI * 2
						const moveDistance = this.gameMap.width * 0.2
						const tx = this.info.x + Math.cos(randomAngle) * moveDistance
						const ty = this.info.y + Math.sin(randomAngle) * moveDistance
						this.move_to(tx, ty)
					}
				}
			}
			
			// 彻底禁用AI玩家的攻击能力
			// 1. 覆盖fireball技能的cast方法
			if (player.skills && player.skills.fireball) {
				player.skills.fireball.cast = function() {
					console.log('AI尝试攻击，但已被禁用')
					return false
				}
				
				// 2. 也替换createFireballEntity方法，确保AI无法创建火球
				player.skills.fireball.createFireballEntity = function() {
					console.log('AI尝试创建火球，但已被禁用')
					return null
				}
			}
			
			// 3. 禁用AI的治疗能力
			if (player.skills && player.skills.heal) {
				player.skills.heal.cast = function() {
					console.log('AI尝试治疗，但已被禁用')
					return false
				}
			}
			
			// 4. 也覆盖Player类的shoot_fireball方法，确保不能通过任何方式发射火球
			player.shoot_fireball = function() {
				console.log('AI尝试直接发射火球，但已被禁用')
				return false
			}
		}
	})
}

// 初始化游戏
const initGame = () => {
	try {
		// 清理之前的游戏对象
		GameObject.clearAll()
		
		// 获取canvas元素并设置上下文
		const canvas = gameCanvas.value
		if (!canvas) {
			console.error('无法获取canvas元素')
			return
		}
		
		const ctx = canvas.getContext('2d')
		
		// 获取容器尺寸
		const container = canvas.parentElement
		canvas.width = container.clientWidth
		canvas.height = container.clientHeight
		
		// 创建游戏地图
		gameMap.value = new SingleMap(ctx, 'second')
		
		// 记录AI总数，重置死亡计数
		totalAiCount.value = gameMap.value.players.filter(p => p.info.role === 'AI').length
		deadAiCount.value = 0
		
		console.log('第二关初始化完成，AI总数:', totalAiCount.value)
		
		// 设置游戏事件回调
		gameMap.value.setEventCallback('onGameOver', handleGameOver)
		gameMap.value.setEventCallback('onPlayerDeath', handlePlayerDeath)
		
		// 修改AI行为，移除攻击能力
		modifyAiBehavior()
		
		// 开始游戏计时器
		startGameTimer()
		
		// 监听窗口大小变化
		window.addEventListener('resize', handleResize)
		
		// 监听键盘事件
		window.addEventListener('keydown', handleKeyDown)
		
		// 重置游戏状态
		gameOver.value = false
		gameWon.value = false
		remainingTime.value = 60
		isPaused.value = false
		showExitConfirm.value = false
	} catch (error) {
		console.error('初始化游戏时出错:', error)
	}
}

// 游戏计时器
const startGameTimer = () => {
	clearInterval(timerInterval.value)
	remainingTime.value = 60 // 重置为60秒
	
	timerInterval.value = setInterval(() => {
		// 仅在游戏未暂停时更新时间
		if (!isPaused.value) {
			remainingTime.value--
			
			// 定期更新AI状态
			updateAiStatus()
			
			// 检查时间是否到期
			if (remainingTime.value <= 0) {
				clearInterval(timerInterval.value)
				handleTimeUp()
			}
			
			// 检查AI是否全部被消灭
			if (aliveAiCount.value === 0 && totalAiCount.value > 0) {
				handleAllAiDefeated()
			}
		}
	}, 1000) // 每秒更新一次
}

// 处理窗口大小变化
const handleResize = () => {
	if (gameMap.value) {
		gameMap.value.resize()
	}
}

// 处理游戏结束事件
const handleGameOver = (won) => {
	gameOver.value = true
	gameWon.value = won
	
	if (won) {
		resultMessage.value = '你已经击败了所有敌人！'
	} else {
		resultMessage.value = '你被敌人击败了！'
	}
	
	clearInterval(timerInterval.value)
}

// 处理时间用完
const handleTimeUp = () => {
	clearInterval(timerInterval.value)
	gameOver.value = true
	
	// 如果AI还活着，玩家失败
	if (aliveAiCount.value > 0) {
		gameWon.value = false
		resultMessage.value = '时间用完了，你没能消灭所有敌人！'
	} else {
		gameWon.value = true
		resultMessage.value = '你成功消灭了所有敌人！'
	}
}

// 处理所有AI被击败
const handleAllAiDefeated = () => {
	clearInterval(timerInterval.value)
	gameOver.value = true
	gameWon.value = true
	resultMessage.value = `你在${Math.ceil(60 - remainingTime.value)}秒内消灭了所有敌人！`
}

// 重新开始游戏
const restartGame = () => {
	initGame()
}

// 模拟通关
const simulateCompletion = () => {
	// 清理资源
	clearInterval(timerInterval.value)
	window.removeEventListener('resize', handleResize)
	
	// 通知父组件关卡完成
	emit('complete')
}

// 处理键盘事件
const handleKeyDown = (event) => {
	// Esc键暂停/恢复游戏
	if (event.key === 'Escape') {
		// 如果显示退出确认，则先关闭
		if (showExitConfirm.value) {
			showExitConfirm.value = false
			return
		}
		
		// 如果游戏已结束，不响应暂停
		if (gameOver.value) {
			return
		}
		
		togglePause()
	}
}

// 暂停/恢复游戏
const togglePause = () => {
	isPaused.value = !isPaused.value
	if (isPaused.value) {
		// 暂停游戏
		GameObject.pause_game()
	} else {
		// 恢复游戏
		GameObject.resume_game()
	}
}

// 恢复游戏
const resumeGame = () => {
	isPaused.value = false
	GameObject.resume_game()
}

// 退出游戏
const exitGame = () => {
	showExitConfirm.value = false
	isPaused.value = false
	
	// 清理游戏计时器
	clearInterval(timerInterval.value)
	
	// 清理游戏实例
	if (gameMap.value) {
		try {
			// 使用静态方法清理所有游戏对象
			GameObject.clearAll()
		} catch (error) {
			console.warn('清理游戏对象时出错:', error)
		}
	}
	
	// 通知父组件退出游戏
	emit('complete')
}

// 处理玩家死亡事件
const handlePlayerDeath = (player) => {
	console.log('玩家死亡:', player.info.role, player.info.username)
	
	// 更新AI计数
	if (player.info.role === 'AI') {
		// 确保标记玩家为死亡状态
		player.is_dead = true
		
		// 更新AI死亡状态统计
		updateAiStatus()
		
		// 检查所有AI状态并输出调试信息
		console.log('AI死亡事件触发，检查所有AI状态:')
		let realAliveCount = 0
		gameMap.value.players.forEach(p => {
			if (p.info.role === 'AI') {
				const isAlive = !p.is_dead && p.info.hp > 0
				if (isAlive) realAliveCount++
				console.log(`AI ${p.info.username} - 死亡状态: ${p.is_dead}, HP: ${p.info.hp}, 存活: ${isAlive}`)
			}
		})
		
		console.log(`AI死亡，真实存活数量: ${realAliveCount}, 计数器存活数量: ${aliveAiCount.value}, 总AI数量: ${totalAiCount.value}`)
		
		// 如果所有AI都死亡，游戏胜利
		if (aliveAiCount.value === 0) {
			handleAllAiDefeated()
		}
	}
}

// 组件挂载时初始化游戏
onMounted(() => {
	console.log('SecondLevel组件已挂载')
	
	// 使用nextTick确保DOM更新完成
	setTimeout(() => {
		if (!gameCanvas.value) {
			console.error('Canvas元素未找到，请检查ref绑定')
		} else {
			console.log('Canvas元素已找到，尺寸:', gameCanvas.value.width, 'x', gameCanvas.value.height)
			
			// 设置canvas焦点，使其能接收键盘事件
			gameCanvas.value.focus()
			
			// 初始化游戏
			initGame()
		}
	}, 100) // 给DOM更新一些时间
})

// 组件卸载时清理资源
onUnmounted(() => {
	// 清理计时器
	clearInterval(timerInterval.value)
	
	// 移除事件监听
	window.removeEventListener('resize', handleResize)
	window.removeEventListener('keydown', handleKeyDown)
	
	// 清理游戏对象
	try {
		GameObject.clearAll()
	} catch (error) {
		console.warn('清理游戏对象时出错:', error)
	}
})

// 监听暂停状态变化
watch(isPaused, (newValue) => {
	// 如果从暂停恢复到正常状态，需要重新获取焦点
	if (!newValue && gameCanvas.value) {
		gameCanvas.value.focus()
	}
})
</script>

<style scoped>
.second-level {
	width: 100%;
	height: 100%;
	position: relative;
	overflow: hidden;
	background: #000;
}

.game-canvas-container {
	position: absolute;
	width: 100%;
	height: 100%;
	top: 0;
	left: 0;
}

canvas {
	display: block;
	background: transparent;
}
</style>
